//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS GroundStation service.
///
/// Welcome to the AWS Ground Station API Reference. AWS Ground Station is a fully managed service that enables you to control satellite communications, downlink and process satellite data, and scale your satellite operations efficiently and cost-effectively without having to build or manage your own ground station infrastructure.
public struct GroundStation: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the GroundStation client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "GroundStation",
            serviceIdentifier: "groundstation",
            serviceProtocol: .restjson,
            apiVersion: "2019-05-23",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: GroundStationErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.dualstack]: .init(endpoints: [
            "af-south-1": "groundstation.af-south-1.api.aws",
            "ap-northeast-2": "groundstation.ap-northeast-2.api.aws",
            "ap-southeast-1": "groundstation.ap-southeast-1.api.aws",
            "ap-southeast-2": "groundstation.ap-southeast-2.api.aws",
            "eu-central-1": "groundstation.eu-central-1.api.aws",
            "eu-north-1": "groundstation.eu-north-1.api.aws",
            "eu-west-1": "groundstation.eu-west-1.api.aws",
            "me-south-1": "groundstation.me-south-1.api.aws",
            "sa-east-1": "groundstation.sa-east-1.api.aws",
            "us-east-1": "groundstation.us-east-1.api.aws",
            "us-east-2": "groundstation.us-east-2.api.aws",
            "us-west-2": "groundstation.us-west-2.api.aws"
        ]),
        [.dualstack, .fips]: .init(endpoints: [
            "us-east-1": "groundstation-fips.us-east-1.api.aws",
            "us-east-2": "groundstation-fips.us-east-2.api.aws",
            "us-west-2": "groundstation-fips.us-west-2.api.aws"
        ]),
        [.fips]: .init(endpoints: [
            "us-east-1": "groundstation-fips.us-east-1.amazonaws.com",
            "us-east-2": "groundstation-fips.us-east-2.amazonaws.com",
            "us-west-2": "groundstation-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Cancels a contact with a specified contact ID.
    @Sendable
    @inlinable
    public func cancelContact(_ input: CancelContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ContactIdResponse {
        try await self.client.execute(
            operation: "CancelContact", 
            path: "/contact/{contactId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels a contact with a specified contact ID.
    ///
    /// Parameters:
    ///   - contactId: UUID of a contact.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelContact(
        contactId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ContactIdResponse {
        let input = CancelContactRequest(
            contactId: contactId
        )
        return try await self.cancelContact(input, logger: logger)
    }

    /// Creates a Config with the specified configData parameters. Only one type of configData can be specified.
    @Sendable
    @inlinable
    public func createConfig(_ input: CreateConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ConfigIdResponse {
        try await self.client.execute(
            operation: "CreateConfig", 
            path: "/config", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a Config with the specified configData parameters. Only one type of configData can be specified.
    ///
    /// Parameters:
    ///   - configData: Parameters of a Config.
    ///   - name: Name of a Config.
    ///   - tags: Tags assigned to a Config.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConfig(
        configData: ConfigTypeData,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ConfigIdResponse {
        let input = CreateConfigRequest(
            configData: configData, 
            name: name, 
            tags: tags
        )
        return try await self.createConfig(input, logger: logger)
    }

    /// Creates a DataflowEndpoint group containing the specified list of DataflowEndpoint objects. The name field in each endpoint is used in your mission profile DataflowEndpointConfig  to specify which endpoints to use during a contact. When a contact uses multiple DataflowEndpointConfig objects, each Config  must match a DataflowEndpoint in the same group.
    @Sendable
    @inlinable
    public func createDataflowEndpointGroup(_ input: CreateDataflowEndpointGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DataflowEndpointGroupIdResponse {
        try await self.client.execute(
            operation: "CreateDataflowEndpointGroup", 
            path: "/dataflowEndpointGroup", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a DataflowEndpoint group containing the specified list of DataflowEndpoint objects. The name field in each endpoint is used in your mission profile DataflowEndpointConfig  to specify which endpoints to use during a contact. When a contact uses multiple DataflowEndpointConfig objects, each Config  must match a DataflowEndpoint in the same group.
    ///
    /// Parameters:
    ///   - contactPostPassDurationSeconds: Amount of time, in seconds, after a contact ends that the Ground Station Dataflow Endpoint Group will be in a POSTPASS state. A Ground Station Dataflow Endpoint Group State Change event will be emitted when the Dataflow Endpoint Group enters and exits the POSTPASS state.
    ///   - contactPrePassDurationSeconds: Amount of time, in seconds, before a contact starts that the Ground Station Dataflow Endpoint Group will be in a PREPASS state. A Ground Station Dataflow Endpoint Group State Change event will be emitted when the Dataflow Endpoint Group enters and exits the PREPASS state.
    ///   - endpointDetails: Endpoint details of each endpoint in the dataflow endpoint group.
    ///   - tags: Tags of a dataflow endpoint group.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDataflowEndpointGroup(
        contactPostPassDurationSeconds: Int? = nil,
        contactPrePassDurationSeconds: Int? = nil,
        endpointDetails: [EndpointDetails],
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DataflowEndpointGroupIdResponse {
        let input = CreateDataflowEndpointGroupRequest(
            contactPostPassDurationSeconds: contactPostPassDurationSeconds, 
            contactPrePassDurationSeconds: contactPrePassDurationSeconds, 
            endpointDetails: endpointDetails, 
            tags: tags
        )
        return try await self.createDataflowEndpointGroup(input, logger: logger)
    }

    /// Creates an Ephemeris with the specified EphemerisData.
    @Sendable
    @inlinable
    public func createEphemeris(_ input: CreateEphemerisRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EphemerisIdResponse {
        try await self.client.execute(
            operation: "CreateEphemeris", 
            path: "/ephemeris", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Ephemeris with the specified EphemerisData.
    ///
    /// Parameters:
    ///   - enabled: Whether to set the ephemeris status to ENABLED after validation. Setting this to false will set the ephemeris status to DISABLED after validation.
    ///   - ephemeris: Ephemeris data.
    ///   - expirationTime: An overall expiration time for the ephemeris in UTC, after which it will become EXPIRED.
    ///   - kmsKeyArn: The ARN of a KMS key used to encrypt the ephemeris in Ground Station.
    ///   - name: A name string associated with the ephemeris. Used as a human-readable identifier for the ephemeris.
    ///   - priority: Customer-provided priority score to establish the order in which overlapping ephemerides should be used. The default for customer-provided ephemeris priority is 1, and higher numbers take precedence. Priority must be 1 or greater
    ///   - satelliteId: AWS Ground Station satellite ID for this ephemeris.
    ///   - tags: Tags assigned to an ephemeris.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEphemeris(
        enabled: Bool? = nil,
        ephemeris: EphemerisData? = nil,
        expirationTime: Date? = nil,
        kmsKeyArn: String? = nil,
        name: String,
        priority: Int? = nil,
        satelliteId: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EphemerisIdResponse {
        let input = CreateEphemerisRequest(
            enabled: enabled, 
            ephemeris: ephemeris, 
            expirationTime: expirationTime, 
            kmsKeyArn: kmsKeyArn, 
            name: name, 
            priority: priority, 
            satelliteId: satelliteId, 
            tags: tags
        )
        return try await self.createEphemeris(input, logger: logger)
    }

    /// Creates a mission profile.  dataflowEdges is a list of lists of strings. Each lower level list of strings has two elements: a from ARN and a to ARN.
    @Sendable
    @inlinable
    public func createMissionProfile(_ input: CreateMissionProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> MissionProfileIdResponse {
        try await self.client.execute(
            operation: "CreateMissionProfile", 
            path: "/missionprofile", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a mission profile.  dataflowEdges is a list of lists of strings. Each lower level list of strings has two elements: a from ARN and a to ARN.
    ///
    /// Parameters:
    ///   - contactPostPassDurationSeconds: Amount of time after a contact ends that you’d like to receive a Ground Station Contact State Change event indicating the pass has finished.
    ///   - contactPrePassDurationSeconds: Amount of time prior to contact start you’d like to receive a Ground Station Contact State Change event indicating an upcoming pass.
    ///   - dataflowEdges: A list of lists of ARNs. Each list of ARNs is an edge, with a from Config and a to Config.
    ///   - minimumViableContactDurationSeconds: Smallest amount of time in seconds that you’d like to see for an available contact. AWS Ground Station will not present you with contacts shorter than this duration.
    ///   - name: Name of a mission profile.
    ///   - streamsKmsKey: KMS key to use for encrypting streams.
    ///   - streamsKmsRole: Role to use for encrypting streams with KMS key.
    ///   - tags: Tags assigned to a mission profile.
    ///   - trackingConfigArn: ARN of a tracking Config.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMissionProfile(
        contactPostPassDurationSeconds: Int? = nil,
        contactPrePassDurationSeconds: Int? = nil,
        dataflowEdges: [[String]],
        minimumViableContactDurationSeconds: Int,
        name: String,
        streamsKmsKey: KmsKey? = nil,
        streamsKmsRole: String? = nil,
        tags: [String: String]? = nil,
        trackingConfigArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MissionProfileIdResponse {
        let input = CreateMissionProfileRequest(
            contactPostPassDurationSeconds: contactPostPassDurationSeconds, 
            contactPrePassDurationSeconds: contactPrePassDurationSeconds, 
            dataflowEdges: dataflowEdges, 
            minimumViableContactDurationSeconds: minimumViableContactDurationSeconds, 
            name: name, 
            streamsKmsKey: streamsKmsKey, 
            streamsKmsRole: streamsKmsRole, 
            tags: tags, 
            trackingConfigArn: trackingConfigArn
        )
        return try await self.createMissionProfile(input, logger: logger)
    }

    /// Deletes a Config.
    @Sendable
    @inlinable
    public func deleteConfig(_ input: DeleteConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ConfigIdResponse {
        try await self.client.execute(
            operation: "DeleteConfig", 
            path: "/config/{configType}/{configId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a Config.
    ///
    /// Parameters:
    ///   - configId: UUID of a Config.
    ///   - configType: Type of a Config.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConfig(
        configId: String,
        configType: ConfigCapabilityType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ConfigIdResponse {
        let input = DeleteConfigRequest(
            configId: configId, 
            configType: configType
        )
        return try await self.deleteConfig(input, logger: logger)
    }

    /// Deletes a dataflow endpoint group.
    @Sendable
    @inlinable
    public func deleteDataflowEndpointGroup(_ input: DeleteDataflowEndpointGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DataflowEndpointGroupIdResponse {
        try await self.client.execute(
            operation: "DeleteDataflowEndpointGroup", 
            path: "/dataflowEndpointGroup/{dataflowEndpointGroupId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a dataflow endpoint group.
    ///
    /// Parameters:
    ///   - dataflowEndpointGroupId: UUID of a dataflow endpoint group.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDataflowEndpointGroup(
        dataflowEndpointGroupId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DataflowEndpointGroupIdResponse {
        let input = DeleteDataflowEndpointGroupRequest(
            dataflowEndpointGroupId: dataflowEndpointGroupId
        )
        return try await self.deleteDataflowEndpointGroup(input, logger: logger)
    }

    /// Deletes an ephemeris
    @Sendable
    @inlinable
    public func deleteEphemeris(_ input: DeleteEphemerisRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EphemerisIdResponse {
        try await self.client.execute(
            operation: "DeleteEphemeris", 
            path: "/ephemeris/{ephemerisId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an ephemeris
    ///
    /// Parameters:
    ///   - ephemerisId: The AWS Ground Station ephemeris ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEphemeris(
        ephemerisId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EphemerisIdResponse {
        let input = DeleteEphemerisRequest(
            ephemerisId: ephemerisId
        )
        return try await self.deleteEphemeris(input, logger: logger)
    }

    /// Deletes a mission profile.
    @Sendable
    @inlinable
    public func deleteMissionProfile(_ input: DeleteMissionProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> MissionProfileIdResponse {
        try await self.client.execute(
            operation: "DeleteMissionProfile", 
            path: "/missionprofile/{missionProfileId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a mission profile.
    ///
    /// Parameters:
    ///   - missionProfileId: UUID of a mission profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMissionProfile(
        missionProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MissionProfileIdResponse {
        let input = DeleteMissionProfileRequest(
            missionProfileId: missionProfileId
        )
        return try await self.deleteMissionProfile(input, logger: logger)
    }

    /// Describes an existing contact.
    @Sendable
    @inlinable
    public func describeContact(_ input: DescribeContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeContactResponse {
        try await self.client.execute(
            operation: "DescribeContact", 
            path: "/contact/{contactId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes an existing contact.
    ///
    /// Parameters:
    ///   - contactId: UUID of a contact.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeContact(
        contactId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeContactResponse {
        let input = DescribeContactRequest(
            contactId: contactId
        )
        return try await self.describeContact(input, logger: logger)
    }

    /// Describes an existing ephemeris.
    @Sendable
    @inlinable
    public func describeEphemeris(_ input: DescribeEphemerisRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEphemerisResponse {
        try await self.client.execute(
            operation: "DescribeEphemeris", 
            path: "/ephemeris/{ephemerisId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes an existing ephemeris.
    ///
    /// Parameters:
    ///   - ephemerisId: The AWS Ground Station ephemeris ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEphemeris(
        ephemerisId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEphemerisResponse {
        let input = DescribeEphemerisRequest(
            ephemerisId: ephemerisId
        )
        return try await self.describeEphemeris(input, logger: logger)
    }

    ///  For use by AWS Ground Station Agent and shouldn't be called directly.  Gets the latest configuration information for a registered agent.
    @Sendable
    @inlinable
    public func getAgentConfiguration(_ input: GetAgentConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAgentConfigurationResponse {
        try await self.client.execute(
            operation: "GetAgentConfiguration", 
            path: "/agent/{agentId}/configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  For use by AWS Ground Station Agent and shouldn't be called directly.  Gets the latest configuration information for a registered agent.
    ///
    /// Parameters:
    ///   - agentId: UUID of agent to get configuration information for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAgentConfiguration(
        agentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAgentConfigurationResponse {
        let input = GetAgentConfigurationRequest(
            agentId: agentId
        )
        return try await self.getAgentConfiguration(input, logger: logger)
    }

    /// Returns Config information. Only one Config response can be returned.
    @Sendable
    @inlinable
    public func getConfig(_ input: GetConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConfigResponse {
        try await self.client.execute(
            operation: "GetConfig", 
            path: "/config/{configType}/{configId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns Config information. Only one Config response can be returned.
    ///
    /// Parameters:
    ///   - configId: UUID of a Config.
    ///   - configType: Type of a Config.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConfig(
        configId: String,
        configType: ConfigCapabilityType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConfigResponse {
        let input = GetConfigRequest(
            configId: configId, 
            configType: configType
        )
        return try await self.getConfig(input, logger: logger)
    }

    /// Returns the dataflow endpoint group.
    @Sendable
    @inlinable
    public func getDataflowEndpointGroup(_ input: GetDataflowEndpointGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDataflowEndpointGroupResponse {
        try await self.client.execute(
            operation: "GetDataflowEndpointGroup", 
            path: "/dataflowEndpointGroup/{dataflowEndpointGroupId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the dataflow endpoint group.
    ///
    /// Parameters:
    ///   - dataflowEndpointGroupId: UUID of a dataflow endpoint group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDataflowEndpointGroup(
        dataflowEndpointGroupId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDataflowEndpointGroupResponse {
        let input = GetDataflowEndpointGroupRequest(
            dataflowEndpointGroupId: dataflowEndpointGroupId
        )
        return try await self.getDataflowEndpointGroup(input, logger: logger)
    }

    /// Returns the number of reserved minutes used by account.
    @Sendable
    @inlinable
    public func getMinuteUsage(_ input: GetMinuteUsageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMinuteUsageResponse {
        try await self.client.execute(
            operation: "GetMinuteUsage", 
            path: "/minute-usage", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the number of reserved minutes used by account.
    ///
    /// Parameters:
    ///   - month: The month being requested, with a value of 1-12.
    ///   - year: The year being requested, in the format of YYYY.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMinuteUsage(
        month: Int,
        year: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMinuteUsageResponse {
        let input = GetMinuteUsageRequest(
            month: month, 
            year: year
        )
        return try await self.getMinuteUsage(input, logger: logger)
    }

    /// Returns a mission profile.
    @Sendable
    @inlinable
    public func getMissionProfile(_ input: GetMissionProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMissionProfileResponse {
        try await self.client.execute(
            operation: "GetMissionProfile", 
            path: "/missionprofile/{missionProfileId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a mission profile.
    ///
    /// Parameters:
    ///   - missionProfileId: UUID of a mission profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMissionProfile(
        missionProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMissionProfileResponse {
        let input = GetMissionProfileRequest(
            missionProfileId: missionProfileId
        )
        return try await self.getMissionProfile(input, logger: logger)
    }

    /// Returns a satellite.
    @Sendable
    @inlinable
    public func getSatellite(_ input: GetSatelliteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSatelliteResponse {
        try await self.client.execute(
            operation: "GetSatellite", 
            path: "/satellite/{satelliteId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a satellite.
    ///
    /// Parameters:
    ///   - satelliteId: UUID of a satellite.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSatellite(
        satelliteId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSatelliteResponse {
        let input = GetSatelliteRequest(
            satelliteId: satelliteId
        )
        return try await self.getSatellite(input, logger: logger)
    }

    /// Returns a list of Config objects.
    @Sendable
    @inlinable
    public func listConfigs(_ input: ListConfigsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConfigsResponse {
        try await self.client.execute(
            operation: "ListConfigs", 
            path: "/config", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of Config objects.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of Configs returned.
    ///   - nextToken: Next token returned in the request of a previous ListConfigs call. Used to get the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConfigs(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConfigsResponse {
        let input = ListConfigsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listConfigs(input, logger: logger)
    }

    /// Returns a list of contacts. If statusList contains AVAILABLE, the request must include groundStation, missionprofileArn, and satelliteArn.
    @Sendable
    @inlinable
    public func listContacts(_ input: ListContactsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContactsResponse {
        try await self.client.execute(
            operation: "ListContacts", 
            path: "/contacts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of contacts. If statusList contains AVAILABLE, the request must include groundStation, missionprofileArn, and satelliteArn.
    ///
    /// Parameters:
    ///   - endTime: End time of a contact in UTC.
    ///   - groundStation: Name of a ground station.
    ///   - maxResults: Maximum number of contacts returned.
    ///   - missionProfileArn: ARN of a mission profile.
    ///   - nextToken: Next token returned in the request of a previous ListContacts call. Used to get the next page of results.
    ///   - satelliteArn: ARN of a satellite.
    ///   - startTime: Start time of a contact in UTC.
    ///   - statusList: Status of a contact reservation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listContacts(
        endTime: Date,
        groundStation: String? = nil,
        maxResults: Int? = nil,
        missionProfileArn: String? = nil,
        nextToken: String? = nil,
        satelliteArn: String? = nil,
        startTime: Date,
        statusList: [ContactStatus],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContactsResponse {
        let input = ListContactsRequest(
            endTime: endTime, 
            groundStation: groundStation, 
            maxResults: maxResults, 
            missionProfileArn: missionProfileArn, 
            nextToken: nextToken, 
            satelliteArn: satelliteArn, 
            startTime: startTime, 
            statusList: statusList
        )
        return try await self.listContacts(input, logger: logger)
    }

    /// Returns a list of DataflowEndpoint groups.
    @Sendable
    @inlinable
    public func listDataflowEndpointGroups(_ input: ListDataflowEndpointGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDataflowEndpointGroupsResponse {
        try await self.client.execute(
            operation: "ListDataflowEndpointGroups", 
            path: "/dataflowEndpointGroup", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of DataflowEndpoint groups.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of dataflow endpoint groups returned.
    ///   - nextToken: Next token returned in the request of a previous ListDataflowEndpointGroups call. Used to get the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDataflowEndpointGroups(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDataflowEndpointGroupsResponse {
        let input = ListDataflowEndpointGroupsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDataflowEndpointGroups(input, logger: logger)
    }

    /// List existing ephemerides.
    @Sendable
    @inlinable
    public func listEphemerides(_ input: ListEphemeridesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEphemeridesResponse {
        try await self.client.execute(
            operation: "ListEphemerides", 
            path: "/ephemerides", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List existing ephemerides.
    ///
    /// Parameters:
    ///   - endTime: The end time to list in UTC. The operation will return an ephemeris if its expiration time is within the time range defined by the startTime and endTime.
    ///   - maxResults: Maximum number of ephemerides to return.
    ///   - nextToken: Pagination token.
    ///   - satelliteId: The AWS Ground Station satellite ID to list ephemeris for.
    ///   - startTime: The start time to list in UTC. The operation will return an ephemeris if its expiration time is within the time range defined by the startTime and endTime.
    ///   - statusList: The list of ephemeris status to return.
    ///   - logger: Logger use during operation
    @inlinable
    public func listEphemerides(
        endTime: Date,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        satelliteId: String,
        startTime: Date,
        statusList: [EphemerisStatus]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEphemeridesResponse {
        let input = ListEphemeridesRequest(
            endTime: endTime, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            satelliteId: satelliteId, 
            startTime: startTime, 
            statusList: statusList
        )
        return try await self.listEphemerides(input, logger: logger)
    }

    /// Returns a list of ground stations.
    @Sendable
    @inlinable
    public func listGroundStations(_ input: ListGroundStationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListGroundStationsResponse {
        try await self.client.execute(
            operation: "ListGroundStations", 
            path: "/groundstation", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of ground stations.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of ground stations returned.
    ///   - nextToken: Next token that can be supplied in the next call to get the next page of ground stations.
    ///   - satelliteId: Satellite ID to retrieve on-boarded ground stations.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGroundStations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        satelliteId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGroundStationsResponse {
        let input = ListGroundStationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            satelliteId: satelliteId
        )
        return try await self.listGroundStations(input, logger: logger)
    }

    /// Returns a list of mission profiles.
    @Sendable
    @inlinable
    public func listMissionProfiles(_ input: ListMissionProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMissionProfilesResponse {
        try await self.client.execute(
            operation: "ListMissionProfiles", 
            path: "/missionprofile", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of mission profiles.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of mission profiles returned.
    ///   - nextToken: Next token returned in the request of a previous ListMissionProfiles call. Used to get the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMissionProfiles(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMissionProfilesResponse {
        let input = ListMissionProfilesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMissionProfiles(input, logger: logger)
    }

    /// Returns a list of satellites.
    @Sendable
    @inlinable
    public func listSatellites(_ input: ListSatellitesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSatellitesResponse {
        try await self.client.execute(
            operation: "ListSatellites", 
            path: "/satellite", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of satellites.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of satellites returned.
    ///   - nextToken: Next token that can be supplied in the next call to get the next page of satellites.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSatellites(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSatellitesResponse {
        let input = ListSatellitesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSatellites(input, logger: logger)
    }

    /// Returns a list of tags for a specified resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of tags for a specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: ARN of a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    ///  For use by AWS Ground Station Agent and shouldn't be called directly.  Registers a new agent with AWS Ground Station.
    @Sendable
    @inlinable
    public func registerAgent(_ input: RegisterAgentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterAgentResponse {
        try await self.client.execute(
            operation: "RegisterAgent", 
            path: "/agent", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  For use by AWS Ground Station Agent and shouldn't be called directly.  Registers a new agent with AWS Ground Station.
    ///
    /// Parameters:
    ///   - agentDetails: Detailed information about the agent being registered.
    ///   - discoveryData: Data for associating an agent with the capabilities it is managing.
    ///   - tags: Tags assigned to an Agent.
    ///   - logger: Logger use during operation
    @inlinable
    public func registerAgent(
        agentDetails: AgentDetails,
        discoveryData: DiscoveryData,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterAgentResponse {
        let input = RegisterAgentRequest(
            agentDetails: agentDetails, 
            discoveryData: discoveryData, 
            tags: tags
        )
        return try await self.registerAgent(input, logger: logger)
    }

    /// Reserves a contact using specified parameters.
    @Sendable
    @inlinable
    public func reserveContact(_ input: ReserveContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ContactIdResponse {
        try await self.client.execute(
            operation: "ReserveContact", 
            path: "/contact", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Reserves a contact using specified parameters.
    ///
    /// Parameters:
    ///   - endTime: End time of a contact in UTC.
    ///   - groundStation: Name of a ground station.
    ///   - missionProfileArn: ARN of a mission profile.
    ///   - satelliteArn: ARN of a satellite
    ///   - startTime: Start time of a contact in UTC.
    ///   - tags: Tags assigned to a contact.
    ///   - logger: Logger use during operation
    @inlinable
    public func reserveContact(
        endTime: Date,
        groundStation: String,
        missionProfileArn: String,
        satelliteArn: String,
        startTime: Date,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ContactIdResponse {
        let input = ReserveContactRequest(
            endTime: endTime, 
            groundStation: groundStation, 
            missionProfileArn: missionProfileArn, 
            satelliteArn: satelliteArn, 
            startTime: startTime, 
            tags: tags
        )
        return try await self.reserveContact(input, logger: logger)
    }

    /// Assigns a tag to a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Assigns a tag to a resource.
    ///
    /// Parameters:
    ///   - resourceArn: ARN of a resource tag.
    ///   - tags: Tags assigned to a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Deassigns a resource tag.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deassigns a resource tag.
    ///
    /// Parameters:
    ///   - resourceArn: ARN of a resource.
    ///   - tagKeys: Keys of a resource tag.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    ///  For use by AWS Ground Station Agent and shouldn't be called directly.  Update the status of the agent.
    @Sendable
    @inlinable
    public func updateAgentStatus(_ input: UpdateAgentStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAgentStatusResponse {
        try await self.client.execute(
            operation: "UpdateAgentStatus", 
            path: "/agent/{agentId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  For use by AWS Ground Station Agent and shouldn't be called directly.  Update the status of the agent.
    ///
    /// Parameters:
    ///   - agentId: UUID of agent to update.
    ///   - aggregateStatus: Aggregate status for agent.
    ///   - componentStatuses: List of component statuses for agent.
    ///   - taskId: GUID of agent task.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAgentStatus(
        agentId: String,
        aggregateStatus: AggregateStatus,
        componentStatuses: [ComponentStatusData],
        taskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAgentStatusResponse {
        let input = UpdateAgentStatusRequest(
            agentId: agentId, 
            aggregateStatus: aggregateStatus, 
            componentStatuses: componentStatuses, 
            taskId: taskId
        )
        return try await self.updateAgentStatus(input, logger: logger)
    }

    /// Updates the Config used when scheduling contacts. Updating a Config will not update the execution parameters for existing future contacts scheduled with this Config.
    @Sendable
    @inlinable
    public func updateConfig(_ input: UpdateConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ConfigIdResponse {
        try await self.client.execute(
            operation: "UpdateConfig", 
            path: "/config/{configType}/{configId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the Config used when scheduling contacts. Updating a Config will not update the execution parameters for existing future contacts scheduled with this Config.
    ///
    /// Parameters:
    ///   - configData: Parameters of a Config.
    ///   - configId: UUID of a Config.
    ///   - configType: Type of a Config.
    ///   - name: Name of a Config.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConfig(
        configData: ConfigTypeData,
        configId: String,
        configType: ConfigCapabilityType,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ConfigIdResponse {
        let input = UpdateConfigRequest(
            configData: configData, 
            configId: configId, 
            configType: configType, 
            name: name
        )
        return try await self.updateConfig(input, logger: logger)
    }

    /// Updates an existing ephemeris
    @Sendable
    @inlinable
    public func updateEphemeris(_ input: UpdateEphemerisRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EphemerisIdResponse {
        try await self.client.execute(
            operation: "UpdateEphemeris", 
            path: "/ephemeris/{ephemerisId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing ephemeris
    ///
    /// Parameters:
    ///   - enabled: Whether the ephemeris is enabled or not. Changing this value will not require the ephemeris to be re-validated.
    ///   - ephemerisId: The AWS Ground Station ephemeris ID.
    ///   - name: A name string associated with the ephemeris. Used as a human-readable identifier for the ephemeris.
    ///   - priority: Customer-provided priority score to establish the order in which overlapping ephemerides should be used. The default for customer-provided ephemeris priority is 1, and higher numbers take precedence. Priority must be 1 or greater
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEphemeris(
        enabled: Bool,
        ephemerisId: String,
        name: String? = nil,
        priority: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EphemerisIdResponse {
        let input = UpdateEphemerisRequest(
            enabled: enabled, 
            ephemerisId: ephemerisId, 
            name: name, 
            priority: priority
        )
        return try await self.updateEphemeris(input, logger: logger)
    }

    /// Updates a mission profile. Updating a mission profile will not update the execution parameters for existing future contacts.
    @Sendable
    @inlinable
    public func updateMissionProfile(_ input: UpdateMissionProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> MissionProfileIdResponse {
        try await self.client.execute(
            operation: "UpdateMissionProfile", 
            path: "/missionprofile/{missionProfileId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a mission profile. Updating a mission profile will not update the execution parameters for existing future contacts.
    ///
    /// Parameters:
    ///   - contactPostPassDurationSeconds: Amount of time after a contact ends that you’d like to receive a Ground Station Contact State Change event indicating the pass has finished.
    ///   - contactPrePassDurationSeconds: Amount of time after a contact ends that you’d like to receive a Ground Station Contact State Change event indicating the pass has finished.
    ///   - dataflowEdges: A list of lists of ARNs. Each list of ARNs is an edge, with a from Config and a to Config.
    ///   - minimumViableContactDurationSeconds: Smallest amount of time in seconds that you’d like to see for an available contact. AWS Ground Station will not present you with contacts shorter than this duration.
    ///   - missionProfileId: UUID of a mission profile.
    ///   - name: Name of a mission profile.
    ///   - streamsKmsKey: KMS key to use for encrypting streams.
    ///   - streamsKmsRole: Role to use for encrypting streams with KMS key.
    ///   - trackingConfigArn: ARN of a tracking Config.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMissionProfile(
        contactPostPassDurationSeconds: Int? = nil,
        contactPrePassDurationSeconds: Int? = nil,
        dataflowEdges: [[String]]? = nil,
        minimumViableContactDurationSeconds: Int? = nil,
        missionProfileId: String,
        name: String? = nil,
        streamsKmsKey: KmsKey? = nil,
        streamsKmsRole: String? = nil,
        trackingConfigArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MissionProfileIdResponse {
        let input = UpdateMissionProfileRequest(
            contactPostPassDurationSeconds: contactPostPassDurationSeconds, 
            contactPrePassDurationSeconds: contactPrePassDurationSeconds, 
            dataflowEdges: dataflowEdges, 
            minimumViableContactDurationSeconds: minimumViableContactDurationSeconds, 
            missionProfileId: missionProfileId, 
            name: name, 
            streamsKmsKey: streamsKmsKey, 
            streamsKmsRole: streamsKmsRole, 
            trackingConfigArn: trackingConfigArn
        )
        return try await self.updateMissionProfile(input, logger: logger)
    }
}

extension GroundStation {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: GroundStation, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension GroundStation {
    /// Return PaginatorSequence for operation ``listConfigs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listConfigsPaginator(
        _ input: ListConfigsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListConfigsRequest, ListConfigsResponse> {
        return .init(
            input: input,
            command: self.listConfigs,
            inputKey: \ListConfigsRequest.nextToken,
            outputKey: \ListConfigsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listConfigs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of Configs returned.
    ///   - logger: Logger used for logging
    @inlinable
    public func listConfigsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListConfigsRequest, ListConfigsResponse> {
        let input = ListConfigsRequest(
            maxResults: maxResults
        )
        return self.listConfigsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactsPaginator(
        _ input: ListContactsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContactsRequest, ListContactsResponse> {
        return .init(
            input: input,
            command: self.listContacts,
            inputKey: \ListContactsRequest.nextToken,
            outputKey: \ListContactsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endTime: End time of a contact in UTC.
    ///   - groundStation: Name of a ground station.
    ///   - maxResults: Maximum number of contacts returned.
    ///   - missionProfileArn: ARN of a mission profile.
    ///   - satelliteArn: ARN of a satellite.
    ///   - startTime: Start time of a contact in UTC.
    ///   - statusList: Status of a contact reservation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactsPaginator(
        endTime: Date,
        groundStation: String? = nil,
        maxResults: Int? = nil,
        missionProfileArn: String? = nil,
        satelliteArn: String? = nil,
        startTime: Date,
        statusList: [ContactStatus],
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContactsRequest, ListContactsResponse> {
        let input = ListContactsRequest(
            endTime: endTime, 
            groundStation: groundStation, 
            maxResults: maxResults, 
            missionProfileArn: missionProfileArn, 
            satelliteArn: satelliteArn, 
            startTime: startTime, 
            statusList: statusList
        )
        return self.listContactsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDataflowEndpointGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataflowEndpointGroupsPaginator(
        _ input: ListDataflowEndpointGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDataflowEndpointGroupsRequest, ListDataflowEndpointGroupsResponse> {
        return .init(
            input: input,
            command: self.listDataflowEndpointGroups,
            inputKey: \ListDataflowEndpointGroupsRequest.nextToken,
            outputKey: \ListDataflowEndpointGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDataflowEndpointGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of dataflow endpoint groups returned.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataflowEndpointGroupsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDataflowEndpointGroupsRequest, ListDataflowEndpointGroupsResponse> {
        let input = ListDataflowEndpointGroupsRequest(
            maxResults: maxResults
        )
        return self.listDataflowEndpointGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listEphemerides(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listEphemeridesPaginator(
        _ input: ListEphemeridesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListEphemeridesRequest, ListEphemeridesResponse> {
        return .init(
            input: input,
            command: self.listEphemerides,
            inputKey: \ListEphemeridesRequest.nextToken,
            outputKey: \ListEphemeridesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listEphemerides(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endTime: The end time to list in UTC. The operation will return an ephemeris if its expiration time is within the time range defined by the startTime and endTime.
    ///   - maxResults: Maximum number of ephemerides to return.
    ///   - satelliteId: The AWS Ground Station satellite ID to list ephemeris for.
    ///   - startTime: The start time to list in UTC. The operation will return an ephemeris if its expiration time is within the time range defined by the startTime and endTime.
    ///   - statusList: The list of ephemeris status to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listEphemeridesPaginator(
        endTime: Date,
        maxResults: Int? = nil,
        satelliteId: String,
        startTime: Date,
        statusList: [EphemerisStatus]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListEphemeridesRequest, ListEphemeridesResponse> {
        let input = ListEphemeridesRequest(
            endTime: endTime, 
            maxResults: maxResults, 
            satelliteId: satelliteId, 
            startTime: startTime, 
            statusList: statusList
        )
        return self.listEphemeridesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listGroundStations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listGroundStationsPaginator(
        _ input: ListGroundStationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListGroundStationsRequest, ListGroundStationsResponse> {
        return .init(
            input: input,
            command: self.listGroundStations,
            inputKey: \ListGroundStationsRequest.nextToken,
            outputKey: \ListGroundStationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listGroundStations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of ground stations returned.
    ///   - satelliteId: Satellite ID to retrieve on-boarded ground stations.
    ///   - logger: Logger used for logging
    @inlinable
    public func listGroundStationsPaginator(
        maxResults: Int? = nil,
        satelliteId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListGroundStationsRequest, ListGroundStationsResponse> {
        let input = ListGroundStationsRequest(
            maxResults: maxResults, 
            satelliteId: satelliteId
        )
        return self.listGroundStationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMissionProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMissionProfilesPaginator(
        _ input: ListMissionProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMissionProfilesRequest, ListMissionProfilesResponse> {
        return .init(
            input: input,
            command: self.listMissionProfiles,
            inputKey: \ListMissionProfilesRequest.nextToken,
            outputKey: \ListMissionProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMissionProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of mission profiles returned.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMissionProfilesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMissionProfilesRequest, ListMissionProfilesResponse> {
        let input = ListMissionProfilesRequest(
            maxResults: maxResults
        )
        return self.listMissionProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSatellites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSatellitesPaginator(
        _ input: ListSatellitesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSatellitesRequest, ListSatellitesResponse> {
        return .init(
            input: input,
            command: self.listSatellites,
            inputKey: \ListSatellitesRequest.nextToken,
            outputKey: \ListSatellitesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSatellites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of satellites returned.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSatellitesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSatellitesRequest, ListSatellitesResponse> {
        let input = ListSatellitesRequest(
            maxResults: maxResults
        )
        return self.listSatellitesPaginator(input, logger: logger)
    }
}

extension GroundStation.ListConfigsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> GroundStation.ListConfigsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension GroundStation.ListContactsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> GroundStation.ListContactsRequest {
        return .init(
            endTime: self.endTime,
            groundStation: self.groundStation,
            maxResults: self.maxResults,
            missionProfileArn: self.missionProfileArn,
            nextToken: token,
            satelliteArn: self.satelliteArn,
            startTime: self.startTime,
            statusList: self.statusList
        )
    }
}

extension GroundStation.ListDataflowEndpointGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> GroundStation.ListDataflowEndpointGroupsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension GroundStation.ListEphemeridesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> GroundStation.ListEphemeridesRequest {
        return .init(
            endTime: self.endTime,
            maxResults: self.maxResults,
            nextToken: token,
            satelliteId: self.satelliteId,
            startTime: self.startTime,
            statusList: self.statusList
        )
    }
}

extension GroundStation.ListGroundStationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> GroundStation.ListGroundStationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            satelliteId: self.satelliteId
        )
    }
}

extension GroundStation.ListMissionProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> GroundStation.ListMissionProfilesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension GroundStation.ListSatellitesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> GroundStation.ListSatellitesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

// MARK: Waiters

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension GroundStation {
    /// Waiter for operation ``describeContact(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilContactScheduled(
        _ input: DescribeContactRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeContactRequest, _>(
            acceptors: [
                .init(state: .failure, matcher: try! JMESPathMatcher("contactStatus", expected: "FAILED_TO_SCHEDULE")),
                .init(state: .success, matcher: try! JMESPathMatcher("contactStatus", expected: "SCHEDULED")),
            ],
            minDelayTime: .seconds(5),
            maxDelayTime: .seconds(900),
            command: self.describeContact
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeContact(_:logger:)``.
    ///
    /// - Parameters:
    ///   - contactId: UUID of a contact.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilContactScheduled(
        contactId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeContactRequest(
            contactId: contactId
        )
        try await self.waitUntilContactScheduled(input, logger: logger)
    }
}
